package cn.iocoder.yudao.module.system.dal.mysql.gugu;

import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.system.dal.dataobject.gugu.MajorAdmissionDO;
import cn.iocoder.yudao.module.system.util.ChineseSegmentationUtil;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.util.StringUtils;

import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * 历年高考专业录取数据 Mapper
 */
@Mapper
public interface MajorAdmissionMapper extends BaseMapperX<MajorAdmissionDO> {

    /**
     * 去除专业名称中括号及其内容的正则表达式
     * 支持中文括号（）和英文括号()
     */
    Pattern MAJOR_NAME_PATTERN = Pattern.compile("[\\(（][^\\)）]*[\\)）]");

    /**
     * 去除专业名称中的括号及其内容
     * 支持中文括号（）和英文括号()
     *
     * @param majorName 原始专业名称
     * @return 处理后的专业名称
     */
    default String removeBrackets(String majorName) {
        if (StringUtils.hasText(majorName)) {
            return MAJOR_NAME_PATTERN.matcher(majorName).replaceAll("").trim();
        }
        return majorName;
    }

    /**
     * 提取专业名称中括号内的所有专业名称
     * 支持中文括号（）和英文括号()
     * 例如：计算机类(计算机科学与技术、软件工程) -> [计算机科学与技术, 软件工程]
     * @param majorName 包含括号的专业名称
     * @return 括号内的专业名称列表
     */
    default List<String> extractMajorNamesFromBrackets(String majorName) {
        List<String> result = new ArrayList<>();

        if (!StringUtils.hasText(majorName)) {
            return result;
        }

        // 同时支持中文括号（）和英文括号()
        int startIndex = -1;
        int endIndex = -1;

        // 查找英文括号
        int englishStart = majorName.indexOf('(');
        int englishEnd = majorName.lastIndexOf(')');

        // 查找中文括号
        int chineseStart = majorName.indexOf('（');
        int chineseEnd = majorName.lastIndexOf('）');

        // 选择最早出现的开始括号
        if (englishStart > 0 && chineseStart > 0) {
            startIndex = Math.min(englishStart, chineseStart);
        } else if (englishStart > 0) {
            startIndex = englishStart;
        } else if (chineseStart > 0) {
            startIndex = chineseStart;
        }

        // 选择对应的结束括号
        if (startIndex == englishStart && englishEnd > startIndex) {
            endIndex = englishEnd;
        } else if (startIndex == chineseStart && chineseEnd > startIndex) {
            endIndex = chineseEnd;
        }

        if (startIndex > 0 && endIndex > startIndex) {
            String bracketContent = majorName.substring(startIndex + 1, endIndex);

            // 按照中文顿号、逗号等分隔符分割
            String[] parts = bracketContent.split("[、，,]");

            for (String part : parts) {
                String trimmed = part.trim();
                if (!trimmed.isEmpty()) {
                    result.add(trimmed);
                }
            }
        }

        return result;
    }

    /**
     * 扩展专业名称列表，包含原始名称和括号内的专业名称
     * @param majorNames 原始专业名称列表
     * @return 扩展后的专业名称列表
     */
    default List<String> expandMajorNamesWithBracketContent(List<String> majorNames) {
        Set<String> expandedNames = new HashSet<>();

        for (String majorName : majorNames) {
            // 添加去除括号后的名称
            String cleanName = removeBrackets(majorName);
            if (StringUtils.hasText(cleanName)) {
                expandedNames.add(cleanName);
            }

            // 添加括号内的专业名称
            List<String> bracketNames = extractMajorNamesFromBrackets(majorName);
            expandedNames.addAll(bracketNames);
        }

        return new ArrayList<>(expandedNames);
    }

    /**
     * 比较两个分数字符串
     *
     * @param score1 分数字符串1
     * @param score2 分数字符串2
     * @return 如果 score1 > score2 返回正数，如果 score1 < score2 返回负数，如果相等返回0
     */
    default int compareScores(String score1, String score2) {
        if (score1 == null && score2 == null) {
            return 0;
        }
        if (score1 == null) {
            return -1;
        }
        if (score2 == null) {
            return 1;
        }

        try {
            // 尝试直接转换为整数进行比较
            int s1 = Integer.parseInt(score1);
            int s2 = Integer.parseInt(score2);
            return Integer.compare(s1, s2);
        } catch (NumberFormatException e) {
            // 如果转换失败，尝试处理分数区间的情况
            try {
                // 如果是区间，取区间的最小值进行比较
                int s1Value = extractMinScore(score1);
                int s2Value = extractMinScore(score2);
                return Integer.compare(s1Value, s2Value);
            } catch (Exception ex) {
                // 如果仍然无法比较，则按字符串比较
                return score1.compareTo(score2);
            }
        }
    }

    /**
     * 从分数字符串中提取最小分数
     *
     * @param score 分数字符串，可能是单一分数或区间（如"673-750"）
     * @return 最小分数值
     */
    default int extractMinScore(String score) {
        if (score.contains("-")) {
            // 如果是区间，取区间的最小值
            String[] parts = score.split("-");
            return Integer.parseInt(parts[0].trim());
        } else {
            // 如果是单一分数，直接转换
            return Integer.parseInt(score.trim());
        }
    }

    /**
     * 根据高校ID、专业名称和年份查询专业录取数据
     *
     * @param schoolUUID 高校唯一ID
     * @param majorName 专业名称
     * @param year 年份
     * @param typeName 专业类型
     * @param provinceName 招生省份
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> selectBySchoolMajorYearTypeNameProvinceName(String schoolUUID, String majorName, Integer year, String typeName, String provinceName) {
        LambdaQueryWrapperX<MajorAdmissionDO> wrapper = new LambdaQueryWrapperX<MajorAdmissionDO>();

        // 添加学校UUID条件（如果不为空）
        if (StringUtils.hasText(schoolUUID)) {
            wrapper.eq(MajorAdmissionDO::getSchoolUuid, schoolUUID);
        }

        // 添加年份条件（必须）
        if (year != null) {
            wrapper.eq(MajorAdmissionDO::getYear, year);
        }

        // 添加类型条件（如果不为空）
        if (StringUtils.hasText(typeName)) {
            wrapper.eq(MajorAdmissionDO::getTypeName, typeName);
        }

        // 添加省份条件（如果不为空）
        if (StringUtils.hasText(provinceName)) {
            wrapper.eq(MajorAdmissionDO::getProvinceName, provinceName);
        }

        // 精确的SQL专业名称匹配（与其他方法保持一致）
        if (StringUtils.hasText(majorName)) {
            final String cleanName = removeBrackets(majorName);

            wrapper.and(w -> {
                // 1. 直接模糊匹配原始专业名称
                w.or().like(MajorAdmissionDO::getMajorName, majorName);

                // 2. 如果去除括号后的名称与原始名称不同，则添加去除括号后的匹配
                if (!cleanName.equals(majorName) && StringUtils.hasText(cleanName)) {
                    w.or().like(MajorAdmissionDO::getMajorName, cleanName);
                }

                // 3. 支持数据库中专业名称包含括号的情况 - 使用模糊匹配而不是精确匹配
                // 匹配数据库中去除括号后的部分包含输入的去除括号后的名称
                w.or().apply("TRIM(SUBSTRING_INDEX(major_name, '(', 1)) LIKE CONCAT('%', {0}, '%')", cleanName);
                w.or().apply("TRIM(SUBSTRING_INDEX(major_name, '（', 1)) LIKE CONCAT('%', {0}, '%')", cleanName);

                // 4. 支持括号内容匹配
                w.or().apply("INSTR(major_name, CONCAT('(', {0})) > 0", cleanName);
                w.or().apply("INSTR(major_name, CONCAT('（', {0})) > 0", cleanName);
                w.or().apply("INSTR(major_name, CONCAT('、', {0})) > 0", cleanName);
                w.or().apply("INSTR(major_name, CONCAT('，', {0})) > 0", cleanName);
            });
        }

        return selectList(wrapper);
    }

    /**
     * 根据高校ID、专业名称、年份和选科组合查询专业录取数据
     *
     * @param schoolUUID 高校唯一ID
     * @param majorName 专业名称
     * @param year 年份
     * @param typeName 专业类型
     * @param provinceName 招生省份
     * @param subjectGroup 选科组合
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> selectBySchoolMajorYearTypeNameProvinceNameAndSubjectGroup(String schoolUUID, String majorName, Integer year, String typeName, String provinceName, String subjectGroup) {
        LambdaQueryWrapperX<MajorAdmissionDO> wrapper = new LambdaQueryWrapperX<MajorAdmissionDO>();

        // 添加学校UUID条件（如果不为空）
        if (StringUtils.hasText(schoolUUID)) {
            wrapper.eq(MajorAdmissionDO::getSchoolUuid, schoolUUID);
        }

        // 添加年份条件（必须）
        if (year != null) {
            wrapper.eq(MajorAdmissionDO::getYear, year);
        }

        // 添加类型条件（如果不为空）
        if (StringUtils.hasText(typeName)) {
            wrapper.eq(MajorAdmissionDO::getTypeName, typeName);
        }

        // 添加省份条件（如果不为空）
        if (StringUtils.hasText(provinceName)) {
            wrapper.eq(MajorAdmissionDO::getProvinceName, provinceName);
        }

        // 添加选科组合条件（如果不为空）
        if (StringUtils.hasText(subjectGroup)) {
            wrapper.eq(MajorAdmissionDO::getSubjectGroup, subjectGroup);
        }

        // 精确的SQL专业名称匹配（与其他方法保持一致）
        if (StringUtils.hasText(majorName)) {
            final String cleanName = removeBrackets(majorName);

            wrapper.and(w -> {
                // 1. 直接模糊匹配原始专业名称
                w.or().like(MajorAdmissionDO::getMajorName, majorName);

                // 2. 如果去除括号后的名称与原始名称不同，则添加去除括号后的匹配
                if (!cleanName.equals(majorName) && StringUtils.hasText(cleanName)) {
                    w.or().like(MajorAdmissionDO::getMajorName, cleanName);
                }

                // 3. 支持数据库中专业名称包含括号的情况 - 使用模糊匹配而不是精确匹配
                // 匹配数据库中去除括号后的部分包含输入的去除括号后的名称
                w.or().apply("TRIM(SUBSTRING_INDEX(major_name, '(', 1)) LIKE CONCAT('%', {0}, '%')", cleanName);
                w.or().apply("TRIM(SUBSTRING_INDEX(major_name, '（', 1)) LIKE CONCAT('%', {0}, '%')", cleanName);

                // 4. 支持括号内容匹配
                w.or().apply("INSTR(major_name, CONCAT('(', {0})) > 0", cleanName);
                w.or().apply("INSTR(major_name, CONCAT('（', {0})) > 0", cleanName);
                w.or().apply("INSTR(major_name, CONCAT('、', {0})) > 0", cleanName);
                w.or().apply("INSTR(major_name, CONCAT('，', {0})) > 0", cleanName);
            });
        }

        return selectList(wrapper);
    }

    /**
     * 根据省份和年份查询专业录取数据
     *
     * @param provinceName 省份名称
     * @param year 年份
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> selectByProvinceAndYear(String provinceName, Integer year) {
        return selectList(new LambdaQueryWrapperX<MajorAdmissionDO>()
                .eq(MajorAdmissionDO::getProvinceName, provinceName)
                .eq(MajorAdmissionDO::getYear, year));
    }

    /**
     * 根据高校名称查询专业录取数据
     *
     * @param schoolName 高校名称
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> selectBySchoolName(String schoolName) {
        return selectList(new LambdaQueryWrapperX<MajorAdmissionDO>()
                .eq(MajorAdmissionDO::getSchoolName, schoolName));
    }

    /**
     * 根据专业名称查询专业录取数据
     *
     * @param majorName 专业名称
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> selectByMajorName(String majorName) {
        if (StringUtils.hasText(majorName)) {
            // 扩展专业名称列表，包含原始名称和括号内的专业名称
            List<String> expandedMajorNames = expandMajorNamesWithBracketContent(Arrays.asList(majorName));

            LambdaQueryWrapperX<MajorAdmissionDO> wrapper = new LambdaQueryWrapperX<MajorAdmissionDO>();
            wrapper.and(w -> {
                for (String expandedName : expandedMajorNames) {
                    if (StringUtils.hasText(expandedName)) {
                        // 1. 直接匹配
                        w.or().like(MajorAdmissionDO::getMajorName, expandedName);

                        // 2. 支持数据库中专业名称包含括号的情况
                        w.or().apply("SUBSTRING_INDEX(major_name, '(', 1) = {0}", expandedName);
                        w.or().apply("SUBSTRING_INDEX(major_name, '（', 1) = {0}", expandedName);

                        // 3. 支持括号内容匹配
                        w.or().apply("INSTR(major_name, CONCAT('(', {0})) > 0", expandedName);
                        w.or().apply("INSTR(major_name, CONCAT('（', {0})) > 0", expandedName);
                        w.or().apply("INSTR(major_name, CONCAT('、', {0})) > 0", expandedName);
                        w.or().apply("INSTR(major_name, CONCAT('，', {0})) > 0", expandedName);
                    }
                }
            });
            return selectList(wrapper);
        } else {
            return selectList();
        }
    }

    /**
     * 根据年份查询专业录取数据
     *
     * @param year 年份
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> selectByYear(Integer year) {
        return selectList(new LambdaQueryWrapperX<MajorAdmissionDO>()
                .eq(MajorAdmissionDO::getYear, year));
    }

    /**
     * 根据选科组合查询专业录取数据
     *
     * @param subjectGroup 选科组合
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> selectBySubjectGroup(String subjectGroup) {
        return selectList(new LambdaQueryWrapperX<MajorAdmissionDO>()
                .eq(MajorAdmissionDO::getSubjectGroup, subjectGroup));
    }

    /**
     * 根据省份、年份和分数范围查询专业录取数据
     *
     * @param provinceName 省份名称
     * @param year 年份
     * @param minScore 最低分数
     * @param maxScore 最高分数
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> selectByProvinceYearAndScoreRange(String provinceName, Integer year, Integer minScore, Integer maxScore) {
        return selectList(new LambdaQueryWrapperX<MajorAdmissionDO>()
                .eq(MajorAdmissionDO::getProvinceName, provinceName)
                .eq(MajorAdmissionDO::getYear, year)
                .apply("CAST(lowest_score AS SIGNED) >= {0}", minScore)
                .apply("CAST(lowest_score AS SIGNED) <= {0}", maxScore));
    }

    /**
     * 根据省份、年份、分数范围和类型查询专业录取数据，并根据专业名称去重
     *
     * @param provinceName 省份名称
     * @param year 年份
     * @param minScore 最低分数
     * @param maxScore 最高分数
     * @param typeName 类型名称，如物理类、历史类等
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> selectByProvinceYearScoreRangeAndType(String provinceName, Integer year, Integer minScore, Integer maxScore, String typeName) {
        // 获取所有符合条件的数据
        List<MajorAdmissionDO> allResults = selectList(new LambdaQueryWrapperX<MajorAdmissionDO>()
                .eq(MajorAdmissionDO::getProvinceName, provinceName)
                .eq(MajorAdmissionDO::getYear, year)
                .eq(StringUtils.hasText(typeName), MajorAdmissionDO::getTypeName, typeName)
                .apply("CAST(lowest_score AS SIGNED) >= {0}", minScore)
                .apply("CAST(lowest_score AS SIGNED) <= {0}", maxScore)
                .last("ORDER BY CAST(lowest_score AS SIGNED) DESC"));

        // 如果没有结果，直接返回空列表
        if (allResults.isEmpty()) {
            return allResults;
        }

        // 使用 Java 代码进行去重
//        Map<String, MajorAdmissionDO> uniqueResults = new LinkedHashMap<>(); // 使用 LinkedHashMap 保持排序
//
//        for (MajorAdmissionDO result : allResults) {
//            // 去除专业名称中的括号及其内容
//            String majorName = result.getMajorName();
//            String cleanMajorName = removeBrackets(majorName);
//
//            // 如果这个专业还没有加入结果集，或者当前结果的最低分比已有结果高，则替换
//            MajorAdmissionDO existingResult = uniqueResults.get(cleanMajorName);
//            if (existingResult == null || compareScores(result.getLowestScore(), existingResult.getLowestScore()) > 0) {
//                uniqueResults.put(cleanMajorName, result);
//            }
//        }

        // 返回去重后的结果
        return new ArrayList<>(allResults);
    }

    /**
     * 根据省份、年份、分数范围和专业名称查询专业录取数据
     *
     * @param provinceName 省份名称
     * @param year 年份
     * @param minScore 最低分数
     * @param maxScore 最高分数
     * @param majorName 专业名称（模糊查询）
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> selectByProvinceYearScoreRangeAndMajorName(String provinceName, Integer year, Integer minScore, Integer maxScore, String majorName) {
        LambdaQueryWrapperX<MajorAdmissionDO> wrapper = new LambdaQueryWrapperX<MajorAdmissionDO>()
                .eq(MajorAdmissionDO::getProvinceName, provinceName)
                .eq(MajorAdmissionDO::getYear, year);

        // 添加分数范围条件
        wrapper.apply("CAST(lowest_score AS SIGNED) >= {0}", minScore);
        wrapper.apply("CAST(lowest_score AS SIGNED) <= {0}", maxScore);

        // 精确的SQL专业名称匹配（与其他方法保持一致）
        if (StringUtils.hasText(majorName)) {
            final String cleanName = removeBrackets(majorName);

            wrapper.and(w -> {
                // 1. 直接模糊匹配原始专业名称
                w.or().like(MajorAdmissionDO::getMajorName, majorName);

                // 2. 如果去除括号后的名称与原始名称不同，则添加去除括号后的匹配
                if (!cleanName.equals(majorName) && StringUtils.hasText(cleanName)) {
                    w.or().like(MajorAdmissionDO::getMajorName, cleanName);
                }

                // 3. 支持数据库中专业名称包含括号的情况 - 使用模糊匹配而不是精确匹配
                // 匹配数据库中去除括号后的部分包含输入的去除括号后的名称
                w.or().apply("TRIM(SUBSTRING_INDEX(major_name, '(', 1)) LIKE CONCAT('%', {0}, '%')", cleanName);
                w.or().apply("TRIM(SUBSTRING_INDEX(major_name, '（', 1)) LIKE CONCAT('%', {0}, '%')", cleanName);

                // 4. 支持括号内容匹配
                w.or().apply("INSTR(major_name, CONCAT('(', {0})) > 0", cleanName);
                w.or().apply("INSTR(major_name, CONCAT('（', {0})) > 0", cleanName);
                w.or().apply("INSTR(major_name, CONCAT('、', {0})) > 0", cleanName);
                w.or().apply("INSTR(major_name, CONCAT('，', {0})) > 0", cleanName);
            });
        }

        return selectList(wrapper);
    }

    /**
     * 根据省份、年份、分数范围和专业名称关键词列表查询专业录取数据
     * 将专业名称拆分为关键词，任何包含这些关键词的专业都会被匹配
     *
     * @param provinceName 省份名称
     * @param year 年份
     * @param minScore 最低分数
     * @param maxScore 最高分数
     * @param majorName 专业名称
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> selectByProvinceYearScoreRangeAndMajorKeywords(String provinceName, Integer year, Integer minScore, Integer maxScore, String majorName) {
        if (!StringUtils.hasText(majorName)) {
            return new ArrayList<>();
        }

        // 简化关键词处理
        List<String> keywords = splitMajorNameToKeywords(majorName);

        // 使用所有关键词，不进行数量限制

        if (keywords.isEmpty()) {
            return new ArrayList<>();
        }

        LambdaQueryWrapperX<MajorAdmissionDO> wrapper = new LambdaQueryWrapperX<MajorAdmissionDO>()
                .eq(MajorAdmissionDO::getProvinceName, provinceName)
                .eq(MajorAdmissionDO::getYear, year);

        // 添加分数范围条件
        wrapper.apply("CAST(lowest_score AS SIGNED) >= {0}", minScore);
        wrapper.apply("CAST(lowest_score AS SIGNED) <= {0}", maxScore);

        // 简化关键词匹配逻辑，只使用简单的LIKE匹配
        final List<String> finalKeywords = new ArrayList<>(keywords);
        wrapper.and(w -> {
            for (String keyword : finalKeywords) {
                if (StringUtils.hasText(keyword)) {
                    // 只使用简单的模糊匹配
                    w.or().like(MajorAdmissionDO::getMajorName, keyword);
                }
            }
        });

        return selectList(wrapper);
    }

    /**
     * 批量查询专业录取分数数据（优化版本，避免 StackOverflowError）
     * @param schoolUUIDs 学校UUID列表
     * @param majorNames 专业名称列表
     * @param year 年份
     * @param typeName 类型名称
     * @param provinceName 省份名称
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> batchSelectAdmissionScores(List<String> schoolUUIDs, List<String> majorNames, Integer year, String typeName, String provinceName) {
        if ((schoolUUIDs == null || schoolUUIDs.isEmpty()) && (majorNames == null || majorNames.isEmpty())) {
            return new ArrayList<>();
        }

        // 优化：当数据量过大时，分批查询避免 SQL 过于复杂
        final int MAX_BATCH_SIZE = 30; // 进一步减小批次大小，避免StackOverflowError

        try {
            if ((schoolUUIDs != null && schoolUUIDs.size() > MAX_BATCH_SIZE) ||
                (majorNames != null && majorNames.size() > MAX_BATCH_SIZE)) {

                // 分批查询
                List<MajorAdmissionDO> allResults = new ArrayList<>();

                // 分批处理学校UUID
                if (schoolUUIDs != null && !schoolUUIDs.isEmpty()) {
                    for (int i = 0; i < schoolUUIDs.size(); i += MAX_BATCH_SIZE) {
                        int endIndex = Math.min(i + MAX_BATCH_SIZE, schoolUUIDs.size());
                        List<String> batchSchoolUUIDs = schoolUUIDs.subList(i, endIndex);

                        try {
                            List<MajorAdmissionDO> batchResults = batchSelectAdmissionScoresSimple(
                                batchSchoolUUIDs, majorNames, year, typeName, provinceName);
                            allResults.addAll(batchResults);
                        } catch (Exception e) {
                            // 记录错误但继续处理其他批次
                            System.err.println("批量查询失败，跳过当前批次: " + e.getMessage());
                        }
                    }
                } else {
                    // 分批处理专业名称
                    for (int i = 0; i < majorNames.size(); i += MAX_BATCH_SIZE) {
                        int endIndex = Math.min(i + MAX_BATCH_SIZE, majorNames.size());
                        List<String> batchMajorNames = majorNames.subList(i, endIndex);

                        try {
                            List<MajorAdmissionDO> batchResults = batchSelectAdmissionScoresSimple(
                                schoolUUIDs, batchMajorNames, year, typeName, provinceName);
                            allResults.addAll(batchResults);
                        } catch (Exception e) {
                            // 记录错误但继续处理其他批次
                            System.err.println("批量查询失败，跳过当前批次: " + e.getMessage());
                        }
                    }
                }

                // 去重（基于主键或唯一标识）
                return allResults.stream()
                    .collect(Collectors.toMap(
                        item -> item.getSchoolUuid() + ":" + item.getMajorName() + ":" + item.getYear(),
                        item -> item,
                        (existing, replacement) -> existing))
                    .values()
                    .stream()
                    .collect(Collectors.toList());
            }

            // 数据量不大时，使用原有逻辑
            return batchSelectAdmissionScoresSimple(schoolUUIDs, majorNames, year, typeName, provinceName);
        } catch (StackOverflowError e) {
            System.err.println("批量查询发生StackOverflowError，返回空结果: " + e.getMessage());
            return new ArrayList<>();
        } catch (Exception e) {
            System.err.println("批量查询发生异常: " + e.getMessage());
            return new ArrayList<>();
        }
    }

    /**
     * 优化查询：根据关键词查询专业录取数据，然后在Java中过滤招生计划和选科要求
     * 使用分步查询替代复杂的JOIN，提高稳定性
     */
    default List<MajorAdmissionDO> selectByProvinceYearScoreRangeAndMajorKeywordsWithEnrollmentPlan(
            String provinceName, Integer year, Integer minScore, Integer maxScore,
            String keyword, List<String> subjects) {

        // 使用简单的查询，避免复杂的SQL语法问题
        return selectByProvinceYearScoreRangeAndMajorKeywords(provinceName, year, minScore, maxScore, keyword);
    }

    /**
     * 优化查询：查询专业录取数据，然后在Java中过滤招生计划和选科要求
     * 使用分步查询替代复杂的JOIN，提高稳定性
     */
    default List<MajorAdmissionDO> selectByProvinceYearScoreRangeWithEnrollmentPlan(
            String provinceName, Integer year, Integer minScore, Integer maxScore,
            List<String> subjects) {

        // 使用简单的查询，避免复杂的SQL语法问题
        return selectByProvinceYearAndScoreRange(provinceName, year, minScore, maxScore);
    }

    /**
     * 根据唯一标识查询专业录取数据是否已存在
     *
     * @param schoolUuid 高校唯一ID
     * @param majorName 专业名称
     * @param year 录取年份
     * @param provinceName 招生省份
     * @param typeName 专业类型
     * @param subjectGroup 选科组合
     * @return 已存在的专业录取数据，如果不存在则返回null
     */
    default MajorAdmissionDO selectByUniqueKey(String schoolUuid, String majorName, Integer year, String provinceName, String typeName, String subjectGroup) {
        LambdaQueryWrapperX<MajorAdmissionDO> wrapper = new LambdaQueryWrapperX<MajorAdmissionDO>()
                .eq(MajorAdmissionDO::getSchoolUuid, schoolUuid)
                .eq(MajorAdmissionDO::getMajorName, majorName)
                .eq(MajorAdmissionDO::getYear, year)
                .eq(MajorAdmissionDO::getProvinceName, provinceName)
                .eq(MajorAdmissionDO::getTypeName, typeName)
                .eq(MajorAdmissionDO::getSubjectGroup, subjectGroup);

        return selectOne(wrapper);
    }

    /**
     * 简化版批量查询专业录取分数数据（避免复杂的括号匹配）
     */
    default List<MajorAdmissionDO> batchSelectAdmissionScoresSimple(List<String> schoolUUIDs, List<String> majorNames, Integer year, String typeName, String provinceName) {
        try {
            // 数据量检查，避免SQL过于复杂
            if ((schoolUUIDs != null && schoolUUIDs.size() > 50) ||
                (majorNames != null && majorNames.size() > 50)) {
                System.err.println("batchSelectAdmissionScoresSimple: 数据量过大，学校数量: " +
                    (schoolUUIDs != null ? schoolUUIDs.size() : 0) +
                    ", 专业数量: " + (majorNames != null ? majorNames.size() : 0));
                return new ArrayList<>();
            }

            LambdaQueryWrapperX<MajorAdmissionDO> wrapper = new LambdaQueryWrapperX<MajorAdmissionDO>();

            // 添加年份条件（必须）
            if (year != null) {
                wrapper.eq(MajorAdmissionDO::getYear, year);
            }

            // 添加类型条件（如果不为空）
//            if (StringUtils.hasText(typeName)) {
//                wrapper.eq(MajorAdmissionDO::getTypeName, typeName);
//            }

            // 添加省份条件（如果不为空）
            if (StringUtils.hasText(provinceName)) {
                wrapper.eq(MajorAdmissionDO::getProvinceName, provinceName);
            }

            // 添加学校UUID条件（如果不为空）
            if (schoolUUIDs != null && !schoolUUIDs.isEmpty()) {
                wrapper.in(MajorAdmissionDO::getSchoolUuid, schoolUUIDs);
            }

            // 改进的专业名称匹配（支持括号匹配）
            if (majorNames != null && !majorNames.isEmpty()) {
                wrapper.and(w -> {
                    for (String originalMajorName : majorNames) {
                        if (StringUtils.hasText(originalMajorName)) {
                            // 获取去除括号后的专业名称
                            String cleanMajorName = removeBrackets(originalMajorName);

                            // 1. 直接模糊匹配原始专业名称
                            w.or().like(MajorAdmissionDO::getMajorName, originalMajorName);

                            // 2. 如果去除括号后的名称与原始名称不同，则添加去除括号后的匹配
                            if (!cleanMajorName.equals(originalMajorName) && StringUtils.hasText(cleanMajorName)) {
                                w.or().like(MajorAdmissionDO::getMajorName, cleanMajorName);
                            }

                            // 3. 支持数据库中专业名称包含括号的情况 - 使用模糊匹配而不是精确匹配
                            // 匹配数据库中去除括号后的部分包含输入的去除括号后的名称
                            w.or().apply("TRIM(SUBSTRING_INDEX(major_name, '(', 1)) LIKE CONCAT('%', {0}, '%')", cleanMajorName);
                            w.or().apply("TRIM(SUBSTRING_INDEX(major_name, '（', 1)) LIKE CONCAT('%', {0}, '%')", cleanMajorName);

                            // 4. 反向匹配：输入的去除括号后的名称包含数据库中去除括号后的名称
                            w.or().apply("CONCAT('%', TRIM(SUBSTRING_INDEX(major_name, '(', 1)), '%') LIKE {0}", cleanMajorName);
                            w.or().apply("CONCAT('%', TRIM(SUBSTRING_INDEX(major_name, '（', 1)), '%') LIKE {0}", cleanMajorName);

                            // 5. 支持括号内容匹配
                            w.or().apply("INSTR(major_name, CONCAT('(', {0})) > 0", cleanMajorName);
                            w.or().apply("INSTR(major_name, CONCAT('（', {0})) > 0", cleanMajorName);
                            w.or().apply("INSTR(major_name, CONCAT('、', {0})) > 0", cleanMajorName);
                            w.or().apply("INSTR(major_name, CONCAT('，', {0})) > 0", cleanMajorName);
                        }
                    }
                });
            }

            return selectList(wrapper);
        } catch (Exception e) {
            System.err.println("简化版批量查询失败: " + e.getMessage());
            return new ArrayList<>();
        }
    }

    /**
     * 简化版批量查询专业录取分数数据（支持选科组合筛选）
     */
    default List<MajorAdmissionDO> batchSelectAdmissionScoresSimpleWithSubjectGroup(List<String> schoolUUIDs, List<String> majorNames, Integer year, String typeName, String provinceName, String subjectGroup) {
        try {
            LambdaQueryWrapperX<MajorAdmissionDO> wrapper = new LambdaQueryWrapperX<MajorAdmissionDO>();

            // 添加年份条件（必须）
            if (year != null) {
                wrapper.eq(MajorAdmissionDO::getYear, year);
            }

            // 添加类型条件（如果不为空）
            if (StringUtils.hasText(typeName)) {
                wrapper.eq(MajorAdmissionDO::getTypeName, typeName);
            }

            // 添加省份条件（如果不为空）
            if (StringUtils.hasText(provinceName)) {
                wrapper.eq(MajorAdmissionDO::getProvinceName, provinceName);
            }

            // 添加选科组合条件（如果不为空）
            if (StringUtils.hasText(subjectGroup)) {
                wrapper.eq(MajorAdmissionDO::getSubjectGroup, subjectGroup);
            }

            // 添加学校UUID条件（如果不为空）
            if (schoolUUIDs != null && !schoolUUIDs.isEmpty()) {
                wrapper.in(MajorAdmissionDO::getSchoolUuid, schoolUUIDs);
            }

            // 改进的专业名称匹配（支持括号匹配）
            if (majorNames != null && !majorNames.isEmpty()) {
                wrapper.and(w -> {
                    for (String originalMajorName : majorNames) {
                        if (StringUtils.hasText(originalMajorName)) {
                            // 获取去除括号后的专业名称
                            String cleanMajorName = removeBrackets(originalMajorName);

                            // 1. 直接模糊匹配原始专业名称
                            w.or().like(MajorAdmissionDO::getMajorName, originalMajorName);

                            // 2. 如果去除括号后的名称与原始名称不同，则添加去除括号后的匹配
                            if (!cleanMajorName.equals(originalMajorName) && StringUtils.hasText(cleanMajorName)) {
                                w.or().like(MajorAdmissionDO::getMajorName, cleanMajorName);
                            }

                            // 3. 支持数据库中专业名称包含括号的情况 - 使用模糊匹配而不是精确匹配
                            // 匹配数据库中去除括号后的部分包含输入的去除括号后的名称
                            w.or().apply("TRIM(SUBSTRING_INDEX(major_name, '(', 1)) LIKE CONCAT('%', {0}, '%')", cleanMajorName);
                            w.or().apply("TRIM(SUBSTRING_INDEX(major_name, '（', 1)) LIKE CONCAT('%', {0}, '%')", cleanMajorName);

                            // 4. 反向匹配：输入的去除括号后的名称包含数据库中去除括号后的名称
                            w.or().apply("CONCAT('%', TRIM(SUBSTRING_INDEX(major_name, '(', 1)), '%') LIKE {0}", cleanMajorName);
                            w.or().apply("CONCAT('%', TRIM(SUBSTRING_INDEX(major_name, '（', 1)), '%') LIKE {0}", cleanMajorName);

                            // 5. 支持括号内容匹配
                            w.or().apply("INSTR(major_name, CONCAT('(', {0})) > 0", cleanMajorName);
                            w.or().apply("INSTR(major_name, CONCAT('（', {0})) > 0", cleanMajorName);
                            w.or().apply("INSTR(major_name, CONCAT('、', {0})) > 0", cleanMajorName);
                            w.or().apply("INSTR(major_name, CONCAT('，', {0})) > 0", cleanMajorName);
                        }
                    }
                });
            }

            return selectList(wrapper);
        } catch (Exception e) {
            System.err.println("简化版批量查询（含选科组合）失败: " + e.getMessage());
            return new ArrayList<>();
        }
    }

    /**
     * 将专业名称拆分为关键词
     *
     * @param majorName 专业名称
     * @return 关键词列表
     */
    default List<String> splitMajorNameToKeywords(String majorName) {
        if (!StringUtils.hasText(majorName)) {
            return new ArrayList<>();
        }

        // 使用中文分词工具类进行分词
        return ChineseSegmentationUtil.segment(majorName);
    }

    /**
     * 根据学校UUID和专业名称查询多年录取数据
     *
     * @param schoolUuid 学校UUID
     * @param majorName 专业名称
     * @param province 省份
     * @param years 年份列表
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> selectBySchoolAndMajor(String schoolUuid, String majorName, String province, List<Integer> years) {
        LambdaQueryWrapperX<MajorAdmissionDO> wrapper = new LambdaQueryWrapperX<MajorAdmissionDO>()
                .eq(MajorAdmissionDO::getSchoolUuid, schoolUuid)
                .eq(MajorAdmissionDO::getProvinceName, province)
                .in(MajorAdmissionDO::getYear, years);

        // 专业名称匹配
        if (StringUtils.hasText(majorName)) {
            final String cleanName = removeBrackets(majorName);
            wrapper.and(w -> {
                w.or().like(MajorAdmissionDO::getMajorName, majorName);
                if (!cleanName.equals(majorName) && StringUtils.hasText(cleanName)) {
                    w.or().like(MajorAdmissionDO::getMajorName, cleanName);
                }
            });
        }

        return selectList(wrapper.orderByDesc(MajorAdmissionDO::getYear));
    }

    /**
     * 根据学校UUID列表和省份查询专业录取数据
     *
     * @param schoolUuids 学校UUID列表
     * @param province 省份
     * @param years 年份列表
     * @param classify 类型
     * @param batch 批次
     * @return 专业录取数据列表
     */
    default List<MajorAdmissionDO> selectListBySchoolUuidsAndProvince(
            List<String> schoolUuids,
            String province,
            List<Integer> years,
            String classify,
            String batch) {
        
        if (schoolUuids == null || schoolUuids.isEmpty()) {
            return new ArrayList<>();
        }
        
        LambdaQueryWrapperX<MajorAdmissionDO> wrapper = new LambdaQueryWrapperX<MajorAdmissionDO>()
                .in(MajorAdmissionDO::getSchoolUuid, schoolUuids);
        
        if (StringUtils.hasText(province)) {
            wrapper.eq(MajorAdmissionDO::getProvinceName, province);
        }
        
        if (years != null && !years.isEmpty()) {
            wrapper.in(MajorAdmissionDO::getYear, years);
        }
        
        if (StringUtils.hasText(classify)) {
            wrapper.eq(MajorAdmissionDO::getTypeName, classify);
        }
        
        if (StringUtils.hasText(batch)) {
            wrapper.eq(MajorAdmissionDO::getBatchName, batch);
        }
        
        return selectList(wrapper);
    }


}
